﻿
/**
 * nPnP - neither Perl not PHP
 *
 * Copyright (C) 2009 Christian Moeller
 *
 * This program is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU General Public License as published by the 
 * Free Software Foundation; either version 3 of the License, or (at your option) 
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. 
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this program; 
 * if not, see <http://www.gnu.org/licenses/>.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace FParser.Runtime
{
    public class RuntimeScope
    {
        private TypeCache types;
        public TypeCache Types
        {
            get { return this.types; }
            set { this.types = value; }
        }

        private MethodCache methods;
        public MethodCache Methods
        {
            get { return this.methods; }
            set { this.methods = value; }
        }

        private LibraryLoader loader;
        public LibraryLoader Loader
        {
            get { return this.loader; }
        }

        private Type[] initLibs = {
                          typeof(Lib_StdIO), 
                          typeof(Lib_Time), 
                          typeof(Lib_Array),
                          typeof(Lib_Thread),
                          typeof(Lib_Core),
                          typeof(Lib_String)
                                  };

        public RuntimeScope()
        {
            this.types = new TypeCache();
            this.methods = new MethodCache();
            this.loader = new LibraryLoader(this);

            foreach (Type type in initLibs)
            {
                this.loader.AddLibrary((IBaseLibrary)Activator.CreateInstance(type));
            }
        }

        private void LoadLibraryMethods(IBaseLibrary lib)
        {
            foreach (ExternalLibraryCall call in lib.Exports)
            {
                this.methods.ExtLibs.Add(call.Method.Name, call);
            }
        }

        public bool HasParameter(int index)
        {
            return this.types.Cache.ContainsKey(index.ToString());
        }

        public BaseType GetParameterBase(int index)
        {
            if (!HasParameter(index))
                return null;
            else
                return types[index.ToString()];
        }

        public string GetParameter(int index)
        {
            if (!HasParameter(index))
                return null;
            else
                return Executor.Executor.CastToValue(types[index.ToString()], this);
        }
    }
}
